`:top
Ein `!Perl-Modul`! ist eine separate `F33f`_`[Komponente`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Komponente_(Software)]`_`f eines `F33f`_`[Computerprogramms`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computerprogramm]`_`f, das in `F33f`_`[Perl`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Perl_(Programmiersprache)]`_`f geschrieben wurde.
Ein Modul besitzt seinen `F33f`_`[Quellcode`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Quellcode]`_`f in einer Moduldatei der Endung `B100`F9d9.pm`f`b, die wiederum ein `B100`F9d9package`f`b beinhaltet, also einen eigenen Namensraum (was allerdings nicht zwingend erforderlich ist); die Struktur des Paketnamens (und damit des Namensraumnamens) spiegelt das Dateisystem wider (sodass das Modul `*Net::FTP`* in der Datei `B100`F9d9Net/FTP.pm`f`b liegt). Darüber hinaus ist ein Perl-Modul mit Namensraum als Klasse zu verwenden, falls `F33f`_`[objektorientierte Programmierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objektorientierte_Programmierung]`_`f angewandt wird (in Perl sind Namensräume äquivalent mit Klassen, müssen jedoch nicht als solche verwendet werden).
Eine Sammlung von Modulen mit zugehöriger Dokumentation, Build-Skripten etc. bildet eine `!`F33f`_`[Distribution`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Distribution_(Software)]`_`f`!. Die Perl-Community pflegt eine große Sammlung an Paketen etc. auf `F33f`_`[CPAN`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=CPAN]`_`f.
Perl als Programmiersprache erlaubt vielfältige Programmierstile. Man kann sowohl ein Modul finden, das prozedural („herkömmlich“, ähnlich wie `F33f`_`[C`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C_(Programmiersprache)]`_`f) geschrieben ist (z. B. `*Test-Simple`*), als auch Module mit objektorientierten Schnittstellen (z. B. `*XML::Parser`*), und sowohl das eine als auch das andere können ihre Aufgaben effizient erfüllen, da es u. a. auf den Kontext ankommt: In Verbindung mit `F33f`_`[XML`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Extensible_Markup_Language]`_`f ist eine objektorientierte Modulschnittstelle sehr viel sinnvoller als z. B. bei einer mathematischen Funktionsbibliothek. Module können auch als `F33f`_`[Mixin`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mixin]`_`f-Methoden genutzt werden oder ein `F33f`_`[Pragma`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Compiler-Anweisung]`_`f sein (z. B. `*strict`*), was dann einen unmittelbaren Effekt auf das Programm hat. Außerdem können Module genutzt werden, um die Syntax der Sprache selbst zu ändern. Module haben meist nur einen Effekt auf den Sichtbarkeitsbereich, in dem sie geladen wurden (meist eine Datei).
Perl-Modulen ist es gemein, eingebettete Dokumentation als `F33f`_`[Plain Old Documentation`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Plain_Old_Documentation]`_`f zu besitzen. POD ist flexibel genug, Artikel, Webseiten oder gar Bücher zu schreiben (z. B. `*Programming Perl`*), im Gegensatz zu `F33f`_`[javadoc`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Javadoc]`_`f, das auf die Dokumentation von Klassen spezialisiert ist. Normalerweise folgen die Dokumentationen der Struktur einer `*`F33f`_`[manpage`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Manpage]`_`f`*.
Der Code auf dieser Seite basiert auf Perl 5.10.0 und sollte somit auch mit Perl > 5.10.0 ausgeführt werden können. Mit beispielsweise Perl 5.6 können insbesondere die Namensraumbeispiele nicht ausgeführt werden. Es wird (Ausnahmen sind gekennzeichnet) das Benutzen des Pragmas `B100`F9d9strict`f`b vorausgesetzt, was saubereren Code zur Folge hat.
>>Contents
• `F0af`_`[Beispiele`#beispiele]`_`f
• `F0af`_`[Prozeduraler Ansatz`#prozeduraler-ansatz]`_`f
• `F0af`_`[Objektorientierter Ansatz`#objektorientierter-ansatz]`_`f
• `F0af`_`[Namensräume und Geltungsbereiche`#namensr-ume-und-geltungsbereiche]`_`f
• `F0af`_`[Siehe auch`#siehe-auch]`_`f
• `F0af`_`[Weblinks`#weblinks]`_`f
-─
>>Beispiele
Eine „Hello-World“-Funktion kann auf verschiedene Weise mit Modulen realisiert werden, wobei es nicht zwingend ist, die Funktion in ein Modul (In Perl eher Namensraum; `B100`F9d9package`f`b) zu packen (im Gegensatz zu `F33f`_`[Java`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_(Programmiersprache)]`_`f); vielmehr kann eine Funktion überall definiert und genutzt werden (in Modulen ebenfalls über Einbindung mit `B100`F9d9use`f`b). Trotzdem ist es aus Gründen der Übersichtlichkeit üblich, die Elemente eines Perl-Moduls in einen Namensraum (`B100`F9d9package`f`b) zu stecken. Eine `*Hello-World`*-Funktion sähe so aus:
`B100`F9d9package module1;`f`b
`B100`F9d9sub hello(){ print "Hello, World!\\n"; }`f`b
>>>Prozeduraler Ansatz
In hello.pm wird die Funktion `B100`F9d9hello()`f`b definiert und implementiert, die im Hauptscript main.pl ausgeführt wird.
`*main.pl`*:
`B100`F9d9#!/usr/bin/perl -w`f`b
`B100`F9d9use strict; # Pragma strict wird genutzt, sodass eine besonders strenge Prüfung durchgeführt wird`f`b
`B100`F9d9use world::hello; # hello.pm world/hello.pm, wobei die Basis-Verzeichnisse, also die Verzeichnis, in denen`f`b
`B100`F9d9 # world/ liegen könnte, in einer Pfadvariable namens @INC angegeben sind, die auch das`f`b
`B100`F9d9 # aktuelle Verzeichnis enthält`f`b
`B100`F9d9`f`b
`B100`F9d9# entweder`f`b
`B100`F9d9hello::hallo();`f`b
`B100`F9d9# oder`f`b
`B100`F9d9hello->hallo("Erde");`f`b
`*hello.pm`*:
`B100`F9d9package hello;`f`b
`B100`F9d9`f`b
`B100`F9d9# Zeilen mit einem "=" kennzeichnen integrierte PO-Dokumentation.`f`b
`B100`F9d9# Ein POD-Abschnitt endet mit "=cut" und kann an beliebiger Stelle stehen.`f`b
`B100`F9d9`f`b
`B100`F9d9=head1 NAME`f`b
`B100`F9d9Hello:World -- DIE Hello-World-Implementierung.`f`b
`B100`F9d9`f`b
`B100`F9d9=head1 ZUSAMMENFASSUNG`f`b
`B100`F9d9`f`b
`B100`F9d9use Hello::World;`f`b
`B100`F9d9hallo();`f`b
`B100`F9d9hallo("Erde");`f`b
`B100`F9d9`f`b
`B100`F9d9=head2 Funktionen`f`b
`B100`F9d9`f`b
`B100`F9d9Folgende Funktionen stehen zur Verfügung:`f`b
`B100`F9d9`f`b
`B100`F9d9=head3 hallo()`f`b
`B100`F9d9`f`b
`B100`F9d9hallo()`f`b
`B100`F9d9hallo($etw_anderes)`f`b
`B100`F9d9`f`b
`B100`F9d9=head1 Autor`f`b
`B100`F9d9`f`b
`B100`F9d9Otto Normalhacker`f`b
`B100`F9d9`f`b
`B100`F9d9=cut`f`b
`B100`F9d9`f`b
`B100`F9d9sub hallo(;$)`f`b
`B100`F9d9{`f`b
`B100`F9d9 my $etw_anderes = shift @_;`f`b
`B100`F9d9 defined $etw_anderes ? print "Hello $etw_anderes !\\n" : print "Hello world!\\n";`f`b
`B100`F9d9}`f`b
`B100`F9d9`f`b
`B100`F9d9return 1; # Jedes Perl-Modul muss einen wahren Wert an den Compiler liefern, sonst gibt es einen Error`f`b
>>>Objektorientierter Ansatz
Objektorientierte Lösungen erfordern in allen Sprachen mehr Code und besitzen eine geringere Effizienz in der Ausführung. Während der Entwicklung ist die Objektorientierung allerdings oft effizienter als eine prozedurale Lösung. In Perl ist die Objektorientierung durch Referenzen (Skalare mit einer Speicheradresse) auf Code und einen Hash realisiert.
`*main.pl`*:
`B100`F9d9#!/usr/bin/perl -w`f`b
`B100`F9d9use strict;`f`b
`B100`F9d9use Hello::World; # Modul liegt in Hello/World.pm`f`b
`B100`F9d9`f`b
`B100`F9d9my $hello = new Hello::World; # Objekt erzeugen`f`b
`B100`F9d9`f`b
`B100`F9d9$hello->gib_begr_aus; # "Hello world" ausgeben`f`b
`B100`F9d9`f`b
`B100`F9d9$hello = $hello->aendere_ding("galaxis"); # Zu begrüßendes Objekt in "Galaxis" ändern und das geänderte Objekt zurückspeichern`f`b
`B100`F9d9`f`b
`B100`F9d9my $begr = $hello->begr_in_string; # Begrüßung speichern...`f`b
`B100`F9d9`f`b
`B100`F9d9print $begr; # und ausgeben`f`b
`*World.pm`*:
`B100`F9d9package Hello::World; # Im objektorientierten Ansatz muss der Namensraum definiert sein, da in Perl jede Klasse ein Namensraum ist`f`b
`B100`F9d9`f`b
`B100`F9d9use strict;`f`b
`B100`F9d9use warnings;`f`b
`B100`F9d9`f`b
`B100`F9d9#`f`b
`B100`F9d9# Eventuelle`f`b
`B100`F9d9# POD-Inhalte`f`b
`B100`F9d9#`f`b
`B100`F9d9`f`b
`B100`F9d9sub new($$) # Prototyp des Konstruktors`f`b
`B100`F9d9{`f`b
`B100`F9d9 my $class = shift @_;`f`b
`B100`F9d9 if ( exists $_[0] ) # Falls nicht anders angegeben, begrüße "world"`f`b
`B100`F9d9 {`f`b
`B100`F9d9 my $ding = $_[0];`f`b
`B100`F9d9 } else`f`b
`B100`F9d9 {`f`b
`B100`F9d9 my $ding = "world";`f`b
`B100`F9d9 }`f`b
`B100`F9d9 my $self = { ding => $ding }; # Hash-Referenz mit Daten wird erzeugt...`f`b
`B100`F9d9 bless($self, $class); # ... mit dem Klassennamen "abgesegnet"...`f`b
`B100`F9d9 return $self; # ...und zurückgegeben`f`b
`B100`F9d9}`f`b
`B100`F9d9`f`b
`B100`F9d9sub aendere_ding($$) # Das Ding ändern, das begrüßt wird`f`b
`B100`F9d9{`f`b
`B100`F9d9 my $self = shift @_; # Objekt annehmen`f`b
`B100`F9d9 my $ding = shift @_;`f`b
`B100`F9d9 $self->{ding} = $ding; # Daten manipulieren...`f`b
`B100`F9d9 return $self; # ...geändertes Objekt zurückgeben`f`b
`B100`F9d9}`f`b
`B100`F9d9`f`b
`B100`F9d9sub gib_begr_aus($) # Die erzeugte Begrüßung auf STDOUT ausgeben`f`b
`B100`F9d9{`f`b
`B100`F9d9 my $self = shift @_; # Objekt wird wieder angenommen...`f`b
`B100`F9d9 print("Hello $self->{ding}!\\n"); # ...und ausgegeben.`f`b
`B100`F9d9}`f`b
`B100`F9d9`f`b
`B100`F9d9sub begr_in_string($) # Die erzeugte Begrüßung als String zurückgeben, z. B. bei Verwendung mit print()`f`b
`B100`F9d9{`f`b
`B100`F9d9 my $self = shift @_;`f`b
`B100`F9d9 return "Hello $self->{ding}!\\n";`f`b
`B100`F9d9}`f`b
>>Namensräume und Geltungsbereiche
Ein Perl-Programm hat zur Laufzeit, sofern nicht anders deklariert, den Namensraum `B100`F9d9main`f`b – eine Funktion `B100`F9d9func1()`f`b kann sowohl als `B100`F9d9func1()`f`b als auch als `B100`F9d9main::func1()`f`b gerufen werden; der Wert von `B100`F9d9$var`f`b kann sowohl über `B100`F9d9$var`f`b als auch mit `B100`F9d9$main::var`f`b herausgefunden werden. Es können jederzeit neue Namensräume deklariert und genutzt werden. Variablen, die mit `B100`F9d9my`f`b deklariert wurden, verfügen über keine Namensraumzugehörigkeit und existieren global, jedoch nur innerhalb einer Datei. Variablen, die mit `B100`F9d9our`f`b deklariert werden, verfügen über eine Namensraumzugehörigkeit und existieren völlig global, also auch über Dateigrenzen hinweg, wobei sie allerdings in einer anderen Datei als der mit der Deklaration (also der einbindenden Datei) mit Scope-Resolution-Operator :: und dem Namensraum gerufen werden müssen. In ein und derselben Datei muss eine our-Variable aus fremdem Namensraum nur dann vollqualifiziert (mit :: und Namensraum) gerufen werden, falls im aufrufenden Namensraum bereits eine our- oder my-Variable desselben Namens existiert.
`B100`F9d9package namensraum1;`f`b
`B100`F9d9my $var = "foo"; # mit my deklarierte Variablen liegen in keinem Namensraum.`f`b
`B100`F9d9 # Ein Rufen mittels $namensraum1::var hat keinen Erfolg, mit $var jedoch überall.`f`b
`B100`F9d9our $var2 = "bar"; # our deklariert eine an den Namensraum gebundene Variable (our ist nur nötig mit strict)`f`b
`B100`F9d9`f`b
`B100`F9d9$namensraum2::var3 = 42; # Namensraum existiert noch nicht, wird dabei aber gleich erstellt. (nur, falls strict nicht genutzt wird)`f`b
`B100`F9d9our $namensraum2::var4 = 21; # Mit und ohne strict: Fehler`f`b
`B100`F9d9my $namensraum2::var5 = 23.11; # Fehler, da my nicht namensraumgebunden ist`f`b
`B100`F9d9`f`b
`B100`F9d9sub namensraum2::hello_w() { print("Hello World!\\n"); } # Geht sowohl mit als auch ohne strict`f`b
>>Siehe auch
• `F33f`_`[Java Archive`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_Archive]`_`f
• `F33f`_`[Objektorientierte Programmierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objektorientierte_Programmierung]`_`f
• `F33f`_`[Perl`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Perl_(Programmiersprache)]`_`f
>>Weblinks
• cpan.org
`c`F0af`_`[↑ Back to top`#top]`_`f`a